////////////////////////////////////////////////////////////////////////////////////////////////////
/// Copyright (c) 2009 - 2010 RacoonStudios
///
/// Permission is hereby granted, free of charge, to any person obtaining a copy of this
/// software and associated documentation files (the "Software"), to deal in the Software
/// without restriction, including without limitation the rights to use, copy, modify, merge,
/// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
/// to whom the Software is furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in all copies or
/// substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
/// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
/// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
/// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
/// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
/// DEALINGS IN THE SOFTWARE.
////////////////////////////////////////////////////////////////////////////////////////////////////

#pragma once
#ifndef dxfloat4_h__
#define dxfloat4_h__

#ifdef RE_USE_DX

#include "math/scalar.h"
#include "math/matrix.h"

 namespace Math
 {
	 class matrix;

	 ////////////////////////////////////////////////////////////////////////////////////////////////////
	 /// \class	float4
	 ///
	 /// \brief	Float 4. 
	 ///
	 /// \author	Markus
	 /// \date	17.02.2010
	 ////////////////////////////////////////////////////////////////////////////////////////////////////
	 __declspec(align(16))
	 class float4
	 {
	 public:

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	float4()
		 ///
		 /// \brief	Default constructor. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 float4();

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	float4(scalar x, scalar y, scalar z, scalar w)
		 ///
		 /// \brief	Constructor. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	x	The x coordinate. 
		 /// \param	y	The y coordinate. 
		 /// \param	z	The z coordinate. 
		 /// \param	w	The w. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 float4(scalar x, scalar y, scalar z, scalar w);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	float4(const XMVECTOR & rhs)
		 ///
		 /// \brief	Constructor. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	rhs	The right hand side. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 float4(XMVECTOR rhs);






		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	void operator= (const float4 & rhs)
		 ///
		 /// \brief	Copy operator. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	rhs	The right hand side. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 void operator = (const float4 & rhs);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	void operator= (XMVECTOR rhs)
		 ///
		 /// \brief	Copy operator. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	rhs	The right hand side. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 void operator = (XMVECTOR rhs);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	bool operator== (const float4 & rhs) const
		 ///
		 /// \brief	Equality operator. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	rhs	The right hand side. 
		 ///
		 /// \return	true if the parameters are considered equivalent. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 bool operator == (const float4 & rhs) const;

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	bool operator!= (const float4 & rhs) const
		 ///
		 /// \brief	Inequality operator. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	rhs	The right hand side. 
		 ///
		 /// \return	true if the parameters are not considered equivalent. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 bool operator != (const float4 & rhs) const;

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	void operator+= (const float4 & rhs)
		 ///
		 /// \brief	Assignment by addition operator. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	rhs	The right hand side. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 void operator += (const float4 & rhs);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	void operator-= (const float4 & rhs)
		 ///
		 /// \brief	Assignment by subtraction operator. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	rhs	The right hand side. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 void operator -= (const float4 & rhs);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	void operator*= (scalar s)
		 ///
		 /// \brief	Assignment by muliplication operator. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	s	The. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 void operator *= (scalar s);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	float4 operator- () const
		 ///
		 /// \brief	Subtraction operator. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \return	The result of the operation. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 float4 operator - () const;

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	float4 operator+ (const float4 & rhs) const
		 ///
		 /// \brief	Addition operator. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	rhs	The right hand side. 
		 ///
		 /// \return	The result of the operation. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 float4 operator + (const float4 & rhs) const;

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	float4 operator- (const float4 & rhs) const
		 ///
		 /// \brief	Negation operator. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	rhs	The right hand side. 
		 ///
		 /// \return	The result of the operation. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 float4 operator - (const float4 & rhs) const;

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	float4 operator* (scalar s) const
		 ///
		 /// \brief	Muliplication operator. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	s	The. 
		 ///
		 /// \return	The result of the operation. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 float4 operator * (scalar s) const;






		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	void set(scalar x, scalar y, scalar z, scalar w)
		 ///
		 /// \brief	Sets. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	x	The scalar to set. 
		 /// \param	y	The scalar to set. 
		 /// \param	z	The scalar to set. 
		 /// \param	w	The scalar to set. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 void set(scalar x, scalar y, scalar z, scalar w);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	void setx(scalar x)
		 ///
		 /// \brief	Setxes. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	x	The x coordinate. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 void setx(scalar x);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	void sety(scalar y)
		 ///
		 /// \brief	Seties. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	y	The y coordinate. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 void sety(scalar y);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	void setz(scalar z)
		 ///
		 /// \brief	Setzs. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	z	The z coordinate. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 void setz(scalar z);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	void setw(scalar w)
		 ///
		 /// \brief	Setws. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	w	The w. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 void setw(scalar w);



		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	scalar & getx()
		 ///
		 /// \brief	Getxes this object. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 scalar & getx();

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	scalar & gety()
		 ///
		 /// \brief	Geties this object. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 scalar & gety();

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	scalar & getz()
		 ///
		 /// \brief	Getzs this object. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 scalar & getz();

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	scalar & getw()
		 ///
		 /// \brief	Getws this object. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 scalar & getw();

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	scalar getx() const
		 ///
		 /// \brief	Getxes this object. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 scalar getx() const;

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	scalar gety() const
		 ///
		 /// \brief	Geties this object. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 scalar gety() const;

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	scalar getz() const
		 ///
		 /// \brief	Getzs this object. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 scalar getz() const;

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	scalar getw() const
		 ///
		 /// \brief	Getws this object. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 scalar getw() const;






		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	scalar length() const
		 ///
		 /// \brief	Lengthes this object. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 scalar length() const;

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	csalar lengthsq() const
		 ///
		 /// \brief	Lengthsqs this object. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 scalar lengthsq() const;

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	float4 abs() const
		 ///
		 /// \brief	Abs this object. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 float4 abs() const;






		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static float4 reciprocal(const float4 & f)
		 ///
		 /// \brief	Reciprocals. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f	The. 
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static float4 reciprocal(const float4 & f);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static float4 multiply(const float4 & f1, const float4 & f2)
		 ///
		 /// \brief	Multiplies. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static float4 multiply(const float4 & f1, const float4 & f2);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static float4 cross3(const float4 & f1, const float4 & f2)
		 ///
		 /// \brief	Cross 3. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static float4 cross3(const float4 & f1, const float4 & f2);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static scalar dot3(const float4 & f1, const float4 & f2)
		 ///
		 /// \brief	Dot 3. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const flaot4 &. 
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static scalar dot3(const float4 & f1, const float4 & f2);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static float4 normalize(const float4 & f)
		 ///
		 /// \brief	Normalizes. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f	The. 
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static float4 normalize(const float4 & f);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static float4 maximize(const float4 & f1, const float4 & f2)
		 ///
		 /// \brief	Maximizes. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static float4 maximize(const float4 & f1, const float4 & f2);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static float4 minimize(const float4 & f1, const float4 & f2)
		 ///
		 /// \brief	Minimizes. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static float4 minimize(const float4 & f1, const float4 & f2);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static float4 barycentric(const float4 & f1, const float4 & f2, const float4 & f3,
		 /// 	scalar f, scalar g)
		 ///
		 /// \brief	Barycentrics. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 /// \param	f3	The third const float4 &. 
		 /// \param	f	The. 
		 /// \param	g	The. 
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static float4 barycentric(const float4 & f1, const float4 & f2, const float4 & f3, scalar f, scalar g);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static float4 catmullrom(const float4 & f1, const float4 & f2, const float4 & f3,
		 /// 	const float4 & f4, scalar s)
		 ///
		 /// \brief	Catmullroms. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 /// \param	f3	The third const float4 &. 
		 /// \param	f4	The fourth const float4 &. 
		 /// \param	s	The. 
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static float4 catmullrom(const float4 & f1, const float4 & f2, const float4 & f3, const float4 & f4, scalar s);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static float4 hermite(const float4 & f1, const float4 & t1, const float4 & f2,
		 /// 	const float4 & t2, scalar s)
		 ///
		 /// \brief	Hermites. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	t1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 /// \param	t2	The second const float4 &. 
		 /// \param	s	The. 
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static float4 hermite(const float4 & f1, const float4 & t1, const float4 & f2, const float4 & t2, scalar s);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static float4 clamp(const float4 & clamp, const float4 & min, const float4 & max)
		 ///
		 /// \brief	Clamps. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	clamp	The clamp. 
		 /// \param	min		The minimum. 
		 /// \param	max		The maximum. 
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static float4 clamp(const float4 & clamp, const float4 & min, const float4 & max);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static float4 reflect(const float4 & n, const float4 & i)
		 ///
		 /// \brief	Reflects. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	n	The. 
		 /// \param	i	The. 
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static float4 reflect(const float4 & n, const float4 & i);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static scalar angle(const float4 & f1, const float4 & f2)
		 ///
		 /// \brief	Angles. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static scalar angle(const float4 & f1, const float4 & f2);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static float4 lerp(const float4 & f1, const float4 & f2, scalar s)
		 ///
		 /// \brief	Lerps. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const &. 
		 /// \param	s	The. 
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static float4 lerp(const float4 & f1, const float4 & f2, scalar s);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static float4 transform(const float4 & f, const matrix & m)
		 ///
		 /// \brief	Transforms. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f	The. 
		 /// \param	m	The. 
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static float4 transform(const float4 & f, const matrix & m);






		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static bool l3_any(const float4 & f1, const float4 & f2)
		 ///
		 /// \brief	3 any. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 ///
		 /// \return	true if it succeeds, false if it fails. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static bool l3_any(const float4 & f1, const float4 & f2);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static bool l3_all(const float4 & f1, const float4 & f2)
		 ///
		 /// \brief	3 all. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 ///
		 /// \return	true if it succeeds, false if it fails. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static bool l3_all(const float4 & f1, const float4 & f2);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static bool le3_any(const float4 & f1, const float4 & f2)
		 ///
		 /// \brief	Le 3 any. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 ///
		 /// \return	true if it succeeds, false if it fails. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static bool le3_any(const float4 & f1, const float4 & f2);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static bool le3_all(const float4 & f1, const float4 & f2)
		 ///
		 /// \brief	Le 3 all. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 ///
		 /// \return	true if it succeeds, false if it fails. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static bool le3_all(const float4 & f1, const float4 & f2);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static bool g3_any(const float4 & f1, const float4 & f2)
		 ///
		 /// \brief	3 any. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 ///
		 /// \return	true if it succeeds, false if it fails. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static bool g3_any(const float4 & f1, const float4 & f2);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static bool g3_all(const float4 & f1, const float4 & f2)
		 ///
		 /// \brief	3 all. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 ///
		 /// \return	true if it succeeds, false if it fails. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static bool g3_all(const float4 & f1, const float4 & f2);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static bool ge3_any(const float4 & f1, const float4 & f2)
		 ///
		 /// \brief	Ge 3 any. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 ///
		 /// \return	true if it succeeds, false if it fails. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static bool ge3_any(const float4 & f1, const float4 & f2);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static bool ge3_all(const float4 & f1, const float4 & f2)
		 ///
		 /// \brief	Ge 3 all. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 ///
		 /// \return	true if it succeeds, false if it fails. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static bool ge3_all(const float4 & f1, const float4 & f2);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static bool e3_any(const float4 & f1, const float4 & f2)
		 ///
		 /// \brief	3 any. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 ///
		 /// \return	true if it succeeds, false if it fails. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static bool e3_any(const float4 & f1, const float4 & f2);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static bool e3_all(const float4 & f1, const float4 & f2)
		 ///
		 /// \brief	3 all. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 ///
		 /// \return	true if it succeeds, false if it fails. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static bool e3_all(const float4 & f1, const float4 & f2);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static bool ne3(const float4 & f1, const float4 & f2, const float4 &epsilon)
		 ///
		 /// \brief	Ne 3. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1		The first const float4 &. 
		 /// \param	f2		The second const float4 &. 
		 /// \param	epsilon	The epsilon. 
		 ///
		 /// \return	true if it succeeds, false if it fails. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static bool ne3(const float4 & f1, const float4 & f2, const float4 &epsilon);



		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static bool l4_any(const float4 & f1, const float4 & f2)
		 ///
		 /// \brief	4 any. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 ///
		 /// \return	true if it succeeds, false if it fails. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static bool l4_any(const float4 & f1, const float4 & f2);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static bool l4_all(const float4 & f1, const float4 & f2)
		 ///
		 /// \brief	4 all. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 ///
		 /// \return	true if it succeeds, false if it fails. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static bool l4_all(const float4 & f1, const float4 & f2);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static bool le4_any(const float4 & f1, const float4 & f2)
		 ///
		 /// \brief	Le 4 any. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 ///
		 /// \return	true if it succeeds, false if it fails. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static bool le4_any(const float4 & f1, const float4 & f2);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static bool le4_all(const float4 & f1, const float4 & f2)
		 ///
		 /// \brief	Le 4 all. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 ///
		 /// \return	true if it succeeds, false if it fails. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static bool le4_all(const float4 & f1, const float4 & f2);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static bool g4_any(const float4 & f1, const float4 & f2)
		 ///
		 /// \brief	4 any. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 ///
		 /// \return	true if it succeeds, false if it fails. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static bool g4_any(const float4 & f1, const float4 & f2);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static bool g4_all(const float4 & f1, const float4 & f2)
		 ///
		 /// \brief	4 all. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 ///
		 /// \return	true if it succeeds, false if it fails. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static bool g4_all(const float4 & f1, const float4 & f2);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static bool ge4_any(const float4 & f1, const float4 & f2v1)
		 ///
		 /// \brief	Ge 4 any. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1		The first const float4 &. 
		 /// \param	f2v1	The first f 2v. 
		 ///
		 /// \return	true if it succeeds, false if it fails. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static bool ge4_any(const float4 & f1, const float4 & f2v1);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static bool ge4_all(const float4 & f1, const float4 & f2)
		 ///
		 /// \brief	Ge 4 all. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 ///
		 /// \return	true if it succeeds, false if it fails. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static bool ge4_all(const float4 & f1, const float4 & f2);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static bool e4_any(const float4 & f1, const float4 & f2)
		 ///
		 /// \brief	4 any. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 ///
		 /// \return	true if it succeeds, false if it fails. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static bool e4_any(const float4 & f1, const float4 & f2);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static bool e4_all(const float4 & f1, const float4 & f2)
		 ///
		 /// \brief	4 all. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1	The first const float4 &. 
		 /// \param	f2	The second const float4 &. 
		 ///
		 /// \return	true if it succeeds, false if it fails. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static bool e4_all(const float4 & f1, const float4 & f2);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static bool ne4(const float4 & f1, const float4 & f2, const float4 &epsilon)
		 ///
		 /// \brief	Ne 4. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f1		The first const float4 &. 
		 /// \param	f2		The second const float4 &. 
		 /// \param	epsilon	The epsilon. 
		 ///
		 /// \return	true if it succeeds, false if it fails. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static bool ne4(const float4 & f1, const float4 & f2, const float4 &epsilon);






		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static scalar unwrapx(XMVECTOR v)
		 ///
		 /// \brief	Unwrapxes. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	v	The v. 
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static scalar unwrapx(XMVECTOR v);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static scalar unwrapy(XMVECTOR v)
		 ///
		 /// \brief	Unwrapies. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	v	The v. 
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static scalar unwrapy(XMVECTOR v);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static scalar unwrapz(XMVECTOR v)
		 ///
		 /// \brief	Unwrapzs. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	v	The v. 
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static scalar unwrapz(XMVECTOR v);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static scalar unwrapw(XMVECTOR v)
		 ///
		 /// \brief	Unwrapws. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	v	The v. 
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static scalar unwrapw(XMVECTOR v);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static float4 wrap(scalar s)
		 ///
		 /// \brief	Wraps. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	s	The. 
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static float4 wrap(scalar s);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static float4 wrapx(const float4 & f)
		 ///
		 /// \brief	Wrapxes. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f	The. 
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static float4 wrapx(const float4 & f);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static float4 wrapy(const float4 & f)
		 ///
		 /// \brief	Wrapies. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f	The. 
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static float4 wrapy(const float4 & f);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static float4 wrapz(const float4 & f)
		 ///
		 /// \brief	Wrapzs. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f	The. 
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static float4 wrapz(const float4 & f);

		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 /// \fn	static float4 wrapw(const float4 & f)
		 ///
		 /// \brief	Wrapws. 
		 ///
		 /// \author	Markus
		 /// \date	17.02.2010
		 ///
		 /// \param	f	The. 
		 ///
		 /// \return	. 
		 ////////////////////////////////////////////////////////////////////////////////////////////////////
		 static float4 wrapw(const float4 & f);



	 protected:

		 friend class matrix;
		 friend class quaternion;
		 friend class point4;
		 friend class plane;

		 XMVECTOR m_vec;

	 private:

	 };

 }

#endif // RE_USE_DX

#endif // dxfloat4_h__